import { Definition } from "../engine/common/definition";
// ====================== 基础数据结构 ======================
export class DataPage {
    constructor(curIndex = 1, total = 0, limitPerPage = Definition.gDefualPageSize) {
        this.curIndex = curIndex;
        this.total = total;
        this.limitPerPage = limitPerPage;
    }

    static fromJson(json) {
        return new DataPage(
            json['pageNum'] || 1,
            json['total'] || 0,
            json['pageSize'] || Definition.gDefualPageSize,
        );
    }
}

export class ApiReturnStruct {
    constructor() {
        this.data = null;       // 解析后的数据
        this.resErr = null;     // 错误信息
        this.errorCode = null;  // 错误代码
    }
}

// ====================== 核心分页数据类 ======================
export class CommunicationPageData {
    constructor() {
        this.dataList = [];          // 数据列表
        this.pageInfo = new DataPage(); // 分页信息
    }

    /**
     * 从服务器响应创建分页数据对象
     * @param {Object} json - 服务器返回的原始数据
     * @param {Function} factory - 数据项的工厂函数 
     * @param {Object} options - 配置项
     * @param {string} [options.listKey='list'] - 列表数据的字段名
     * @param {boolean} [options.withPageInfo=true] - 是否包含分页信息
     */
    static createFromJson(json, fromJsonFunction, options = {}) {
        const instance = new CommunicationPageData();
        const { listKey = 'list', withPageInfo = true } = options;

        if (json[listKey]) {
            instance.dataList = Array.isArray(json[listKey])
                ? json[listKey].map(item => fromJsonFunction(item))
                : [];
        }

        if (withPageInfo) {
            instance.pageInfo = DataPage.fromJson(json);
        }

        return instance;
    }


}

// ====================== 网络响应解析器 ======================
export class NetworkParser {
    /**
     * 解析网络响应
     * @param {Object} networkResponse - 原始网络响应
     * @param {Function} DataClass - 目标数据类（需已注册）
     * @param {Object} options - 配置项
     * @param {boolean} [options.isPageData=false] - 是否为分页数据
     * @returns {ApiReturnStruct} 解析结果
     */
    static parseNetworkResult(networkResponse, fromJsonFunction, options = {}) {
        const result = new ApiReturnStruct();
        const { isPageData = false, isListData = false } = options;

        try {
            // 预处理响应数据
            const response = networkResponse;

            if (!response) {
                result.resErr = '无效的服务器响应';
                return result;
            }

            // 处理成功响应
            if (response.success) {
                this._handleSuccess(response, result, fromJsonFunction, isPageData,isListData);
            }
            // 处理错误响应
            else {
                this._handleError(response, result);
            }
        } catch (error) {
            this._handleParseError(error, result);
        }

        return result;
    }


        /**
     * 直接转换列表数据（无分页信息）
     * @param {Array} list - 原始数据列表
     * @param {Function} fromJsonFunction - 数据项的工厂函数
     */
    static createFromList(jsonList, fromJsonFunction) {        
        let dataList = Array.isArray(jsonList)
            ? jsonList.map(item => fromJsonFunction(item))
            : [];
        return dataList;
    }
    static _handleSuccess(response, result, fromJsonFunction, isPageData, isListData) {
        // 没有提供构造回调函数时，不校验data
        // 因为如删除之类操作，没有data 返回，也不需要构造对象
        if (!response.data && fromJsonFunction) {
            result.resErr = '服务器返回空数据';
            return;
        }


        if (isPageData) {
            result.data = CommunicationPageData.createFromJson(
                response.data,
                fromJsonFunction,
                { listKey: 'list' }
            );
        } 
        else if(isListData)
        {
             result.data = NetworkParser.createFromList( response.data,fromJsonFunction);
        }
        else {
            result.data = fromJsonFunction
                ? fromJsonFunction(response.data)
                : response.data;
        }
    }

    static _handleError(response, result) {
        const errorCode = response.code?.toString();
        const defaultMessage = '服务器返回错误';

        // 特殊错误码处理
        switch (errorCode) {
            case 'ReLoginNeed':
                this._triggerRelogin();
                result.resErr = '登录过期，请重新登录';
                result.errorCode = errorCode;
                break;
            default:
                result.resErr = response.msg || defaultMessage;
                result.errorCode = errorCode || 'unknown';
        }
    }

    static _handleParseError(error, result) {
        console.error('解析错误:', error);
        result.resErr = `数据解析失败: ${error.message}`;
        result.errorCode = 'PARSE_ERROR';
    }

    static _triggerRelogin() {
        // 实现重新登录逻辑
        console.log('执行重新登录...');
        // 示例：清除登录状态并跳转
        // uni.redirectTo({ url: '/pages/login' });
    }
}

///  接口信息
/// networkFunc 网络接口函数地址
/// T 返回的数据类型


export async function getApiData(fromJsonFunction, orgId, pageInfo, networkFunc, filter = {}, showLoading = true) {
    const result = new ApiReturnStruct();

    try {
        //console.log('----> getApiData1');
        // 调用网络接口，获取数据
        const netWorkData = await networkFunc(
            {
                orgId: orgId,
                pageInfo: pageInfo,
                filter: filter,
                showLoading: showLoading
            });

        //console.log('----> getApiData2:', netWorkData);

        // 解析数据，利用 NetworkParser 解析分页数据
        const communityData = NetworkParser.parseNetworkResult(netWorkData, fromJsonFunction, {
            isPageData: true // 指明是分页数据
        });

        // 如果解析成功，将数据赋值给返回对象
        if (!communityData.resErr) {
            result.data = communityData.data;
        } else {
            result.resErr = communityData.resErr;
        }

    } catch (e) {
        // 错误处理
        result.resErr = e.toString();
    }

    return result;
}

